package wox.lonice.service.impl;

import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import wox.lonice.dao.UserMapper;
import wox.lonice.entity.DataRow;
import wox.lonice.entity.User;
import wox.lonice.service.UserService;

@Service
public class UserServiceImpl implements UserService{
	
	private static Logger logger = LoggerFactory.getLogger(UserService.class);

	/**
	 * 用户信息操作Mapper
	 */
	@Autowired
	private UserMapper userMapper;
	
	public void checUsernameAndPassword(){
		User user = userMapper.checkUserNameAndPassword("123", "123");
		if(user == null){
			//验证失败
		} else {
			//验证成功
			//TODO
		}
	}
	
	@Override
	public void useService() {
		logger.info("123123");
		System.out.println(22);
	}

	@Override
	public List<DataRow> queryUser(String id) {
		List<DataRow> dataRowList = userMapper.queryUser("1");
		for(DataRow dataRow: dataRowList){
			System.out.println(dataRow.get("id") + "  " + dataRow.get("name") + "  " + dataRow.get("username"));
		}
		return dataRowList;
	}

	/**
	 * @Transactional(isolation = Isolation.READ_UNCOMMITTED) 	读取未提交数据(会出现脏读， 不可重复读) 基本不使用
	 * @Transactional(isolation = Isolation.READ_COMMITTED)(SQLSERVER默认) 	读取已提交数据(会出现不可重复读和幻读)
	 * @Transactional(isolation = Isolation.REPEATABLE_READ) 	可重复读(会出现幻读)
	 * @Transactional(isolation = Isolation.SERIALIZABLE) 	串行化
	 * @Transactional(propagation=Propagation.REQUIRED) 	如果有事务， 那么加入事务， 没有的话新建一个(默认情况下)
	 * @Transactional(propagation=Propagation.NOT_SUPPORTED)  	容器不为这个方法开启事务
	 * @Transactional(propagation=Propagation.REQUIRES_NEW)  	不管是否存在事务，都创建一个新的事务，原来的挂起，新的执行完毕，继续执行老的事务
	 * @Transactional(propagation=Propagation.MANDATORY)  	必须在一个已有的事务中执行，否则抛出异常
	 * @Transactional(propagation=Propagation.NEVER) 	必须在一个没有的事务中执行，否则抛出异常(与Propagation.MANDATORY相反)
	 * @Transactional(propagation=Propagation.SUPPORTS)  	如果其他bean调用这个方法，在其他bean中声明事务，那就用事务。如果其他bean没有声明事务，那就
	 * isolation 枚举org.springframework.transaction.annotation.Isolation的值 事务隔离级别 
	 * noRollbackFor  Class<? extends Throwable>[] 一组异常类，遇到时不回滚。默认为{}
	 * noRollbackForClassName  Stirng[] 一组异常类名，遇到时不回滚，默认为{}
	 * propagation  枚举org.springframework.transaction.annotation.Propagation的值 事务传播行为 
	 * readOnly  boolean 事务读写性 
	 * rollbackFor  Class<? extends Throwable>[] 一组异常类，遇到时回滚 
	 * rollbackForClassName  Stirng[] 一组异常类名，遇到时回滚 
	 * timeout  int 超时时间，以秒为单位 
	 * value  String 可选的限定描述符，指定使用的事务管理器 
	 */
	@Override
	@Transactional
	public int updateUser(DataRow dataRow) throws Exception {
		int updateCount = userMapper.updateUser(dataRow);
		System.out.println("updateUser:	" + updateCount);
		if(updateCount > 0){
			throw new RuntimeException("中断更新，回滚吧");
		}
		return 0;
	}
	

	
}
